﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Web;
using System.Data;
using System.Data.SqlClient;
using System.Diagnostics;
using System.Configuration;

namespace Xmobile.BO
{
    public static class Libs
    {
        public static string Ext = ConfigurationManager.AppSettings["ext"].ToString();
        public static string[] mobiles = new string[] {
                                                    "iphone","opera mini","opera mobi", "sony", "htc", "ericsson", "moto", "panasonic", "sharp", "philips", "samsung"
                                                    , "android", "nokia", "blackberry", "galaxy"
                                             };
        public static bool IsMobileRedirect(HttpContext context)
        {
            bool isReturn = false;
            if (context.Request.Browser["IsMobileDevice"] == "true")
            {
                isReturn = true;
            }
            return isReturn;
        }

        public static bool isMobileBrowser(HttpContext context)
        {

            //GETS THE CURRENT USER CONTEXT
            // HttpContext context = HttpContext.Current;
            if (context.Request.ServerVariables["HTTP_USER_AGENT"] != null)
            {
                var ua = (context.Request.ServerVariables["HTTP_USER_AGENT"].ToLower());
                if (ua.Contains("Android".ToLower()) && !ua.Contains("mobile".ToLower())) { return false; } // Android tablet
                if (ua.Contains("A500 Build/HRI66".ToLower())) { return false; }// Acer Inconia Tab A500/Picasso
                if (ua.Contains("A100 Build/HRI66".ToLower())) { return false; }// Acer Inconia Tab A100/Vangogh
            }

            //FIRST TRY BUILT IN ASP.NT CHECK
            if (context.Request.Browser.IsMobileDevice)
            {
                return true;
            }
            //THEN TRY CHECKING FOR THE HTTP_X_WAP_PROFILE HEADER
            if (context.Request.ServerVariables["HTTP_X_WAP_PROFILE"] != null)
            {
                return true;
            }
            //THEN TRY CHECKING THAT HTTP_ACCEPT EXISTS AND CONTAINS WAP
            if (context.Request.ServerVariables["HTTP_ACCEPT"] != null &&
                context.Request.ServerVariables["HTTP_ACCEPT"].ToLower().Contains("wap"))
            {
                return true;
            }
            //AND FINALLY CHECK THE HTTP_USER_AGENT 
            //HEADER VARIABLE FOR ANY ONE OF THE FOLLOWING
            if (context.Request.ServerVariables["HTTP_USER_AGENT"] != null)
            {



                //Loop through each item in the list created above 
                //and check if the header contains that text
                foreach (string s in mobiles)
                {
                    if (context.Request.ServerVariables["HTTP_USER_AGENT"].
                                                        ToLower().Contains(s.ToLower()))
                    {
                        return true;
                    }
                }
            }

            return false;
        }
        /*
        public static string GetCategoryDisplayByCategoryId(int categoryId)
        {
            string ret = "";
            using (DataTable dtCategory = ExecuteDataTable(ConfigurationManager.ConnectionStrings["CafeFConnMaster"].ConnectionString, "CacheMonitor_News_GetCategoryByCategoryId", CommandType.StoredProcedure, new SqlParameter("@Cat_ID", categoryId)))
            {
                if (null != dtCategory && dtCategory.Rows.Count > 0)
                {
                    ret = dtCategory.Rows[0]["Cat_DisplayURL"].ToString();
                }
            }
            return ret;
        }
        */
        public static int GetParentCategoryIdByCategoryId(int categoryId)
        {
            //string cacheName = string.Format("CacheMonitor_News_GetCategoryByCategoryId_{0}", categoryId);
            //int ret = Libs.Object2Integer(HttpContext.Current.Cache[cacheName]);
            //if (ret == 0)
            //{
            //    using (
            //        DataTable dtCategory =
            //            ExecuteDataTable(ConfigurationManager.ConnectionStrings["CafeFConnBDSMaster"].ConnectionString,
            //                             "CacheMonitor_News_GetCategoryByCategoryId", CommandType.StoredProcedure,
            //                             new SqlParameter("@Cat_ID", categoryId)))
            //    {
            //        if (null != dtCategory && dtCategory.Rows.Count > 0)
            //        {
            //            ret = Libs.Object2Integer(dtCategory.Rows[0]["Cat_ParentID"]);
            //            if (ret == 0)
            //            {
            //                ret = Libs.Object2Integer(dtCategory.Rows[0]["Cat_ID"]);
            //            }
            //            HttpContext.Current.Cache.Add(cacheName, ret, null, DateTime.Now.AddDays(30), TimeSpan.Zero,
            //                                          CacheItemPriority.Normal, null);
            //        }
            //    }
            //}
            //return ret;

            return 0;
        }


        /// <summary>
        /// Kiem tra xem chuoi co phai la so hay khong ? True : la so; False : ko phai
        /// </summary>
        /// <param name="Value"></param>
        /// <returns></returns>
        public static bool CheckInt(string Value)
        {
            if (Value == String.Empty)
                return false;
            if (Value == null)
                return false;
            foreach (char c in Value)
            {
                int i;

                i = Convert.ToInt16(c);

                if ((i > 57) || (i < 48))
                    return false;
            }
            return true;
        }
       

        #region Template cho tin chi tiết
        private static List<NewsDetailTemplate> _Templates;
        public struct NewsDetailTemplate
        {
            public string catid, name, template;
            public NewsDetailTemplate(string _catid, string _name, string _template)
            {
                this.catid = _catid;
                this.name = _name;
                this.template = _template;
            }
        }
        
        #endregion

        /// <summary>
        /// Chuyển đổi 1 giá trị sang kiểu Integer
        /// </summary>
        /// <param name="value">Giá trị cần chuyển đổi</param>
        /// <returns>Số kiểu Integer, nếu lỗi return int.MinValue</returns>
        public static int Object2Integer(object value)
        {
            if (null == value) return 0;
            try
            {
                return Convert.ToInt32(value);
            }
            catch
            {
                return 0;
            }
        }
        /// <summary>
        /// Chuyển đổi 1 giá trị sang kiểu Long
        /// </summary>
        /// <param name="value">Giá trị cần chuyển đổi</param>
        /// <returns>Số kiểu Long, nếu lỗi return long.MinValue</returns>
        public static long Object2Long(object value)
        {
            if (null == value) return 0;
            try
            {
                return Convert.ToInt64(value);
            }
            catch
            {
                return 0;
            }
        }
        /// <summary>
        /// Chuyển đổi 1 giá trị sang kiểu Double
        /// </summary>
        /// <param name="value">Giá trị cần chuyển đổi</param>
        /// <returns>Số kiểu Double, nếu lỗi return double.NaN</returns>
        public static double Object2Double(object value)
        {
            if (null == value) return 0;
            try
            {
                return Convert.ToDouble(value);
            }
            catch
            {
                return 0;
            }
        }
        /// <summary>
        /// Chuyển đổi 1 giá trị sang kiểu float
        /// </summary>
        /// <param name="value">Giá trị cần chuyển đổi</param>
        /// <returns>Số kiểu float, nếu lỗi return float.NaN</returns>
        public static float Object2Float(object value)
        {
            if (null == value) return 0;
            try
            {
                return float.Parse(value.ToString());
            }
            catch
            {
                return 0;
            }
        }
        /// <summary>
        /// Chuyển đổi 1 giá trị sang kiểu boolean
        /// </summary>
        /// <param name="value">Giá trị cần chuyển đổi</param>
        /// <returns>giá trị kiểu boolean, nếu lỗi return false</returns>
        public static bool Object2Boolean(object value)
        {
            if (null == value) return false;
            try
            {
                return Convert.ToBoolean(value);
            }
            catch
            {
                return false;
            }
        }
        /// <summary>
        /// Chuyển đổi 1 giá trị sang kiểu DateTime
        /// </summary>
        /// <param name="value">Giá trị cần chuyển đổi</param>
        /// <returns>Số kiểu DateTime, nếu lỗi return DateTime.MinValue</returns>
        public static DateTime Object2DateTime(object value)
        {
            if (null == value) return DateTime.MinValue;
            try
            {
                return Convert.ToDateTime(value);
            }
            catch
            {
                return DateTime.MinValue;
            }
        }
        /// <summary>
        /// Chuyển đổi 1 xâu ngày tháng dạng dd/MM/yyyy sang ngày tháng
        /// </summary>
        /// <param name="value">Xâu nhập</param>
        /// <returns>Trả về kiểu DateTime cua ngày cần chuyển đổi (Nếu lỗi thì trả về DateTime.MinValue)</returns>
        public static DateTime String2Date(string value)
        {
            string temp = value;

            string date = temp.Substring(0, temp.IndexOf("/"));
            temp = temp.Substring(temp.IndexOf("/") + 1);
            string month = temp.Substring(0, temp.IndexOf("/"));
            string year = temp.Substring(temp.IndexOf("/") + 1);

            string[] months = new string[] { "jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec" };
            try
            {
                return Convert.ToDateTime(date + " " + months[Convert.ToInt32(month) - 1] + " " + year);
            }
            catch
            {
                return DateTime.MinValue;
            }
        }
        /// <summary>
        /// Lấy 1 xâu ngẫu nhiên
        /// </summary>
        /// <param name="length">Số lượng ký tự</param>
        /// <returns>Xâu ngẫu nhiên</returns>
        public static string GetRamdomString(int length)
        {
            string temp = "";
            string[] myAlphabet = new string[] { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z" };

            Random Rnd = new Random();
            for (int i = 0; i < length; i++)
            {
                temp += myAlphabet[Rnd.Next(0, myAlphabet.Length - 1)];
            }
            return temp;
        }

        #region Chuyen doi xau dang unicode co dau sang dang khong dau
        private const string KoDauChars =
            "aaaaaaaaaaaaaaaaaeeeeeeeeeeediiiiiooooooooooooooooouuuuuuuuuuuyyyyyAAAAAAAAAAAAAAAAAEEEEEEEEEEEDIIIOOOOOOOOOOOOOOOOOOOUUUUUUUUUUUYYYYYAADOOU";

        private const string uniChars =
            "àáảãạâầấẩẫậăằắẳẵặèéẻẽẹêềếểễệđìíỉĩịòóỏõọôồốổỗộơờớởỡợùúủũụưừứửữựỳýỷỹỵÀÁẢÃẠÂẦẤẨẪẬĂẰẮẲẴẶÈÉẺẼẸÊỀẾỂỄỆĐÌÍỈĨỊÒÓỎÕỌÔỒỐỔỖỘƠỜỚỞỠỢÙÚỦŨỤƯỪỨỬỮỰỲÝỶỸỴÂĂĐÔƠƯ";

        /// <summary>
        /// Chuyển đổi 1 xâu từ dạng unicode có dấu sang dạng unicode không dấu
        /// </summary>
        /// <param name="s">xâu unicode có dấu</param>
        /// <returns>xâu unicode không dấu đã convert</returns>
        public static string UnicodeToKoDau(string s)
        {
            string retVal = String.Empty;
            s = s.Trim();
            int pos;
            for (int i = 0; i < s.Length; i++)
            {
                pos = uniChars.IndexOf(s[i].ToString());
                if (pos >= 0)
                    retVal += KoDauChars[pos];
                else
                    retVal += s[i];
            }
            return retVal;
        }

        /// <summary>
        /// Chuyển đổi 1 xâu từ dạng unicode có dấu sang dạng unicode không dấu và có gạch ngăn cách giữa mỗi từ
        /// </summary>
        /// <param name="s">xâu unicode có dấu</param>
        /// <returns>xâu unicode không dấu và có gạch ngăn cách giữa mỗi từ</returns>
        public static string UnicodeToKoDauAndGach(string s)
        {
            string strChar = "abcdefghiklmnopqrstxyzuvxw0123456789 ";
            //string retVal = UnicodeToKoDau(s);
            //s = s.Replace("-", " ");
            s = s.Replace("–", "");
            s = s.Replace("  ", " ");
            s = UnicodeToKoDau(s.ToLower().Trim());
            string sReturn = "";
            for (int i = 0; i < s.Length; i++)
            {
                if (strChar.IndexOf(s[i]) > -1)
                {
                    if (s[i] != ' ')
                        sReturn += s[i];
                    else if (i > 0 && s[i - 1] != ' ' && s[i - 1] != '-')
                        sReturn += "-";
                }
            }

            return sReturn;
        }
        #endregion

        #region QueryStrings
        public static class QueryString
        {
            public static int CategoryID
            {
                get
                {
                    int catId = 0;


                    if (string.IsNullOrEmpty(HttpContext.Current.Request.Params["catid"])) catId = 0;

                    catId = Libs.Object2Integer(HttpContext.Current.Request.Params["catid"]);

                    return catId;
                }
                //get
                //{
                //    if (string.IsNullOrEmpty(HttpContext.Current.Request.QueryString["cat_id"])) return 0;

                //    return Libs.Object2Integer(HttpContext.Current.Request.QueryString["cat_id"]);
                //}
            }

            public static string OS
            {
                get
                {
                    if (string.IsNullOrEmpty(HttpContext.Current.Request.Params["os"])) return "0";

                    return HttpContext.Current.Request.Params["os"].ToString();
                }
            }

            public static int Sticky
            {
                get
                {
                    if (string.IsNullOrEmpty(HttpContext.Current.Request.Params["sticky"])) return 0;

                    return Libs.Object2Integer(HttpContext.Current.Request.Params["sticky"]);
                }
            }

            public static int CategoryParentID
            {
                get
                {
                    if (string.IsNullOrEmpty(HttpContext.Current.Request.Params["cat_parentid"])) return 0;

                    return Libs.Object2Integer(HttpContext.Current.Request.Params["cat_parentid"]);
                }
            }

            public static string ParentCategory
            {
                get
                {
                    return GetParentCategoryIdByCategoryId(CategoryID).ToString();
                }
            }
            public static string CategoryName
            {
                get
                {
                    if (string.IsNullOrEmpty(HttpContext.Current.Request.Params["catid"])) return "0";

                    return HttpContext.Current.Request.QueryString["catid"];
                }
            }
            public static int PageIndex
            {
                get
                {
                    if (string.IsNullOrEmpty(HttpContext.Current.Request.Params["pageindex"])) return 0;

                    return Libs.Object2Integer(HttpContext.Current.Request.Params["pageindex"]);
                }
            }
            public static int ProductId
            {
                get
                {

                    if (string.IsNullOrEmpty(HttpContext.Current.Request.Params["appid"])) return 0;

                    return Libs.Object2Integer(HttpContext.Current.Request.Params["appid"]);
                }
            }


            public static string DateSearch
            {
                get
                {
                    string day = "1", month = "1", year = "1111";
                    if (!string.IsNullOrEmpty(HttpContext.Current.Request.QueryString["day"]))
                    {
                        day = HttpContext.Current.Request.QueryString["day"].ToString();
                    }

                    if (!string.IsNullOrEmpty(HttpContext.Current.Request.QueryString["month"]))
                    {
                        month = HttpContext.Current.Request.QueryString["month"].ToString();
                    }

                    if (!string.IsNullOrEmpty(HttpContext.Current.Request.QueryString["year"]))
                    {
                        year = HttpContext.Current.Request.QueryString["year"].ToString();
                    }

                    if (day == "1" && month == "1" && year == "1111")
                    {
                        return "0";
                    }

                    return day + "/" + month + "/" + year;
                }
            }

            public static int ViewByDate_Day
            {
                get
                {
                    if (string.IsNullOrEmpty(HttpContext.Current.Request.QueryString["day"])) return 0;

                    return Libs.Object2Integer(HttpContext.Current.Request.QueryString["day"]);
                }
            }
            public static int ViewByDate_Month
            {
                get
                {
                    if (string.IsNullOrEmpty(HttpContext.Current.Request.QueryString["month"])) return 0;

                    return Libs.Object2Integer(HttpContext.Current.Request.QueryString["month"]);
                }
            }
            public static int ViewByDate_Year
            {
                get
                {
                    if (string.IsNullOrEmpty(HttpContext.Current.Request.QueryString["year"])) return 0;

                    return Libs.Object2Integer(HttpContext.Current.Request.QueryString["year"]);
                }
            }
            public static int PageType
            {
                get
                {
                    if (string.IsNullOrEmpty(HttpContext.Current.Request.QueryString["PageType"])) return 0;

                    return Libs.Object2Integer(HttpContext.Current.Request.QueryString["PageType"]);
                }
            }
            public static int ThreadID
            {
                get
                {
                    if (string.IsNullOrEmpty(HttpContext.Current.Request.QueryString["ThreadID"])) return 0;

                    return Libs.Object2Integer(HttpContext.Current.Request.QueryString["ThreadID"]);
                }
            }

            public static int SubID
            {
                get
                {
                    int subid;
                    if (string.IsNullOrEmpty(HttpContext.Current.Request.QueryString["SubID"])) subid = 0;
                    else
                        subid = Libs.Object2Integer(HttpContext.Current.Request.QueryString["SubID"]);

                    if (subid == -1)
                        subid = 0;

                    return subid;
                }
            }

            public static int Template
            {
                get
                {
                    if (string.IsNullOrEmpty(HttpContext.Current.Request.QueryString["key_template"])) return 0;

                    return Libs.Object2Integer(HttpContext.Current.Request.QueryString["key_template"]);
                }
            }



            public static int KeyTemplate
            {
                get
                {
                    if (string.IsNullOrEmpty(HttpContext.Current.Request.QueryString["key_template"])) return 0;

                    return Libs.Object2Integer(HttpContext.Current.Request.QueryString["key_template"]);
                }
            }
        }

        #endregion

        

        #region SqlHelper
        public static int ExecuteNoneQuery(string connectionString, string commandText, CommandType commandType, params SqlParameter[] sqlParams)
        {
            using (SqlConnection cnn = new SqlConnection(connectionString))
            {
                using (SqlCommand cmd = new SqlCommand(commandText, cnn))
                {
                    cmd.CommandType = commandType;

                    foreach (SqlParameter param in sqlParams)
                    {
                        cmd.Parameters.Add(param);
                    }

                    int returnValue = 0;

                    cnn.Open();
                    returnValue = cmd.ExecuteNonQuery();
                    cnn.Close();

                    return returnValue;
                }
            }
        }

        public static DataTable ExecuteDataTable(string connectionString, string commandText, CommandType commandType, params SqlParameter[] sqlParams)
        {
            using (SqlConnection cnn = new SqlConnection(connectionString))
            {
                using (SqlCommand cmd = new SqlCommand(commandText, cnn))
                {
                    cmd.CommandType = commandType;

                    foreach (SqlParameter param in sqlParams)
                    {
                        cmd.Parameters.Add(param);
                    }

                    using (SqlDataAdapter adapter = new SqlDataAdapter(cmd))
                    {
                        DataTable dtReturnValue = new DataTable();
                        adapter.Fill(dtReturnValue);
                        return dtReturnValue;
                    }
                }
            }
        }

        public static DataTable ExecuteDataTable(string connectionString, string commandText, CommandType commandType, int startRecord, int maxRecord, params SqlParameter[] sqlParams)
        {
            using (SqlConnection cnn = new SqlConnection(connectionString))
            {
                using (SqlCommand cmd = new SqlCommand(commandText, cnn))
                {
                    cmd.CommandType = commandType;

                    foreach (SqlParameter param in sqlParams)
                    {
                        cmd.Parameters.Add(param);
                    }

                    using (SqlDataAdapter adapter = new SqlDataAdapter(cmd))
                    {
                        DataTable dtReturnValue = new DataTable();
                        adapter.Fill(startRecord, maxRecord, dtReturnValue);
                        return dtReturnValue;
                    }
                }
            }
        }
        #endregion

      
    }
}
